home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Compilers⁄Interps / kevoSource / portBrowser.c < prev    next >
Text File  |  1993-05-12  |  37KB  |  1,401 lines
  1. /* Kevo -- a prototype-based object-oriented language */
  2. /* (c) Antero Taivalsaari 1991-1993                   */
  3. /* Some parts (c) Antero Taivalsaari 1986-1988           */
  4. /* portBrowser.c: Non-portable object browser          */
  5.  
  6. #include "global.h"
  7. #include "portGlobal.h"
  8.  
  9. /*---------------------------------------------------------------------------*/
  10. /* Graphical user interface (GUI) initialization */
  11.  
  12. /* Open and initialize the browser */
  13.  
  14. void openBrowser(target, windowIdent, browserKind)
  15. OBJECT* target;            /* The object to be browsed */
  16. char*    windowIdent;    /* The (partial) name of the window */
  17. int        browserKind;    /* Browser kind (either BrowserWKind or CloneBrWKind) */
  18. {
  19.   WindowPtr     browserWindow;
  20.   WindowPtr        frontWindow;
  21.   GrafPtr        savePort;
  22.   WINFO*        thisWinfo;
  23.   ListHandle    iconList;
  24.   int            wKind;
  25.   int            columns;        /* Initial number of columns in the browser */
  26.   int            viewWhat;        /* Initial view mode (ALL, BEHAVIOR, DATA) */
  27.  
  28.     /* Check if we can find an existing browser for the requested object */
  29.     browserWindow = findBrowser(target);
  30.  
  31.     /* If we can, then select the existing browser */
  32.     if (browserWindow) {
  33.         /* If the window is hidden, make it visible */
  34.         if (!((WindowPeek)browserWindow)->visible) ShowWindow(browserWindow);
  35.         SelectWindow(browserWindow);
  36.           return;
  37.       }
  38.       
  39.     /* Otherwise, open a new browser window for the requested object */
  40.  
  41.     /* First, check if the currently selected window is a browser window */
  42.     frontWindow = FrontWindow();
  43.     wKind = getWindowKind(frontWindow);
  44.  
  45.     /*     If the front window is a browser window, then we'll 
  46.         duplicate the view mode information from that window.
  47.     */
  48.     if (wKind == BrowserWKind || wKind == CloneBrWKind) {
  49.         iconList = getBrowserIcons(frontWindow);        
  50.  
  51.         /* If we are opening a clone family, always display both data and behavior */
  52.         if (browserKind == CloneBrWKind)
  53.              viewWhat = ALL;
  54.         else viewWhat = getViewMode(iconList);
  55.         columns  = ((*iconList)->dataBounds).right;
  56.     }
  57.     /* Otherwise, use the default view mode settings */
  58.     /* (defaults: view both data and behavior, one column display) */
  59.     else {
  60.         viewWhat = ALL;
  61.         columns = 1;
  62.     } 
  63.  
  64.     /* Build a new window */
  65.     browserWindow = buildWindow("\p");
  66.     ShowWindow(browserWindow);
  67.  
  68.       GetPort(&savePort);
  69.     SetPort(browserWindow);
  70.  
  71.     TextFont(newYork);
  72.     TextFace(0);
  73.     TextSize(10);
  74.  
  75.     SetPort(savePort);
  76.  
  77.     /* Change the window kind to the requested kind */
  78.     thisWinfo = (WINFO*)GetWRefCon(browserWindow);
  79.     thisWinfo->wKind = browserKind;
  80.  
  81.     /* Store the window identifier to the appropriate field */
  82.     setBrowserIdent(browserWindow, windowIdent);
  83.  
  84.     /* 
  85.         If there are no previous browser windows open, 
  86.         create a new task called 'browserTask', and set 
  87.         it to execute the shell in the root context.
  88.  
  89.         This task will allow many commands given from the browser
  90.         to be executed on background, thus making the browser snappier. 
  91.     */
  92.     if (browserCount == 0) {
  93.       TASK** tempUp = up;
  94.       
  95.         browserTask = buildTask();
  96.         setTaskBehavior(browserTask, oShell);
  97.         setTaskCWD(browserTask, oUserRoot);
  98.  
  99.         /* Browser task does not normally refer to any window */ 
  100.         (*browserTask)->window = NIL;
  101.  
  102.         /* Instead, its output goes to '/dev/null' :-) */
  103.         /* and error messages to the console */
  104.         up = browserTask;
  105.         errfile = confile;
  106.         up = tempUp;
  107.         
  108.         /* Browser task also has its own error handler */
  109.         /* to avoid deadlocks as a result of errors within */
  110.         /* critical regions (which are used for method redefinitions) */ 
  111.         textToKeyBuffer(browserTask, "' brError MY error !");
  112.         crsToKeyBuffer(browserTask);
  113.  
  114.         activateTask(browserTask);
  115.     }
  116.     
  117.     /* Browser window refers to an icon list via its WINFO structure */ 
  118.     iconList = buildIconList(browserWindow, target, LastBrowser, columns, viewWhat);
  119.     setBrowserIcons(browserWindow, iconList);
  120.     LActivate(TRUE, iconList);
  121.  
  122.     LastBrowser = browserWindow;
  123.     browserCount++;
  124.  
  125.     SelectWindow(browserWindow);
  126. }
  127.  
  128.  
  129. /* Reuse a previous browser window by making it display another object */
  130.  
  131. void reuseBrowser(target, windowIdent, oldBrowser, newKind)
  132. OBJECT* target;            /* The object to be browsed */
  133. char* windowIdent;        /* The (partial) window name */
  134. WindowPtr oldBrowser;    /* An existing browser window */
  135. int newKind;            /* The new browser kind (BrowserWKind, CloneBrWKind) */
  136. {
  137.   WindowPtr    existingBrowser;
  138.   WINFO*    thisWinfo;
  139.   
  140.     /* Check if we can find an existing browser for the requested object */
  141.     existingBrowser = findBrowser(target);
  142.  
  143.     /* If we can, then select the existing browser */
  144.     /* And delete the old one */
  145.     if (existingBrowser) {
  146.         deleteBrowser(oldBrowser);
  147.         SelectWindow(existingBrowser);
  148.           return;
  149.       }
  150.       
  151.     /* Change the browser task context to the requested object */
  152.     setBrowserTarget(oldBrowser, target);
  153.     
  154.     /* Change the window kind to the requested kind */
  155.     thisWinfo = (WINFO*)GetWRefCon(oldBrowser);
  156.     thisWinfo->wKind = newKind;
  157.  
  158.     /* Store the window identifier to the appropriate field */
  159.     setBrowserIdent(oldBrowser, windowIdent);
  160.  
  161.     /* Update the browser view using the new target */
  162.     /* and old parameters from the LINFO structure */
  163.     updateBrowser(oldBrowser);
  164. }
  165.  
  166.     
  167. /* Finalize and delete a given browser */
  168.  
  169. void deleteBrowser(browserWindow)
  170. WindowPtr    browserWindow;
  171. {
  172.     ListHandle iconList = getBrowserIcons(browserWindow);
  173.  
  174.     if (browserCount > 1 || (browserCount == 1 && killTask(browserTask))) {
  175.         unlinkBrowser(browserWindow);
  176.         deleteIconList(iconList);
  177.         deleteWinfo(browserWindow);
  178.         DisposeWindow(browserWindow);
  179.         if (--browserCount == 0) browserTask = NIL;
  180.     }    
  181.     else fprintf(confile, "== Cannot delete the only active task in the system ==\n");
  182. }
  183.  
  184.  
  185. /* Unlink the given browser from the browser list */
  186.  
  187. void unlinkBrowser(browserWindow)
  188. WindowPtr browserWindow;
  189. {
  190.     WindowPtr prevBr = NIL;
  191.     WindowPtr thisBr = LastBrowser; 
  192.  
  193.     while (thisBr) {
  194.         if (browserWindow == thisBr) {
  195.             if (!prevBr) LastBrowser = getPrevBrowser(thisBr);
  196.             else setPrevBrowser(prevBr, getPrevBrowser(thisBr));
  197.             return;
  198.         }    
  199.         prevBr = thisBr;
  200.         thisBr = getPrevBrowser(thisBr);
  201.     }
  202. }
  203.  
  204.  
  205. /* Given an object, find the possible corresponding browser from the browser list */
  206.  
  207. WindowPtr findBrowser(target)
  208. OBJECT* target;
  209. {
  210.     WindowPtr thisBr = LastBrowser;
  211.  
  212.     while (thisBr) {
  213.         if (getBrowserTarget(thisBr) == target) return(thisBr);
  214.         thisBr = getPrevBrowser(thisBr);
  215.     }
  216.     return(NIL);
  217. }
  218.  
  219.  
  220. /* Update the view of the given browser */
  221.  
  222. void refreshBrowser(browserWindow)
  223. WindowPtr browserWindow;
  224. {
  225.   ListHandle     iconList = getBrowserIcons(browserWindow);
  226.   OBJECT*         cwd = getBrowserTarget(browserWindow);
  227.   CONTEXT*         thisContext = getContext(cwd);
  228.   PAIR*         thisPair = thisContext->firstPair;
  229.   int            viewMode = getViewMode(iconList);
  230.   Cell             cell;
  231.   short         len;
  232.   OBJECT*         object;                 
  233.   PAIR*         valuePair;
  234.   int            stillMore;
  235.   int            count;
  236.  
  237.     /* 
  238.         If we are displaying a clone family, we should remove the possible extra
  239.         slots from the end of the object by optimizing the list
  240.     */ 
  241.     if (getWindowKind(browserWindow) == CloneBrWKind) optimizeList((LIST*)cwd);
  242.  
  243.     /* Resize the Mac Icon List by counting the number of cells in the object */
  244.     resizeIconList(iconList, cwd);
  245.         
  246.     /* Display each property in the object in the Icon List */
  247.     cell.h = 0; cell.v = 0;
  248.     while (thisPair = getNextMaskedPair(thisPair, viewMode)) {
  249.         int pairKind = recognizeObject(thisPair->ofa);
  250.         int hidden   = thisPair->ffa & HiddenFlag;
  251.         
  252.         switch (pairKind) {
  253.             case PRIMITIVE:
  254.                 len = sprintf(charbuffer, "%s %s", asString(pairKind, hidden), thisPair->nfa);
  255.                 break;
  256.  
  257.             case REF: 
  258.             case VAR: 
  259.             case CONST: 
  260.             {
  261.                 switch (pairKind) {
  262.                     case REF:     object = *getREFslot(thisPair);      break;
  263.                     case VAR:     object = *getVARslot(cwd, thisPair); break;
  264.                     case CONST: object = *getREFslot(thisPair);      break;
  265.                 }
  266.                 
  267.                 if (isContextObject(object)) {
  268.                     if (valuePair = findTypeForward(object)) 
  269.                          len = sprintf(charbuffer, "%s %s (%s)", asString(pairKind, hidden), 
  270.                                     thisPair->nfa, valuePair->nfa);
  271.                     else len = sprintf(charbuffer, "%s %s (<no type>:%d)", asString(pairKind, hidden),
  272.                                     thisPair->nfa, object);
  273.                 }
  274.                 else len = sprintf(charbuffer, "%s %s (%d)", asString(pairKind, hidden), 
  275.                                     thisPair->nfa, object);
  276.                 break;
  277.             }
  278.             case METHOD:
  279.                 len = sprintf(charbuffer, "%s %s", asString(pairKind, hidden), thisPair->nfa);
  280.                 break;
  281.         }
  282.     
  283.         LSetCell(charbuffer, len, cell, iconList);
  284.         stillMore = LNextCell(TRUE, TRUE, &cell, iconList);
  285.         thisPair = thisPair->sfa;
  286.     }
  287.  
  288.     if (viewMode != BEHAVIOR) {
  289.         /* Add the possible anonymous array slots to the end of the icon list */
  290.         count = AnonymousSlots;
  291.         while (count) {
  292.             object = (OBJECT*)*((int*)cwd->mfa + cwd->sfa - count);
  293.             if (isContextObject(object)) {
  294.                 if (valuePair = findTypeForward(object))
  295.                      len = sprintf(charbuffer, "<%d> (%s:%d) ", cwd->sfa-count-1, valuePair->nfa, object);
  296.                 else len = sprintf(charbuffer, "<%d> (<no type>:%d) ", cwd->sfa-count-1, object); 
  297.             }
  298.             else len = sprintf(charbuffer, "<%d> (%d) ", cwd->sfa-count-1, object);
  299.             
  300.             LSetCell(charbuffer, len, cell, iconList);
  301.             stillMore = LNextCell(TRUE, TRUE, &cell, iconList);
  302.             count--;
  303.         } 
  304.     }
  305.  
  306.     /* Empty the rest of the cells in the Icon List */
  307.     if (stillMore) {
  308.         /* Old implementation:
  309. //           LClrCell(cell, iconList);
  310. //           while (LNextCell(TRUE, TRUE, &cell, iconList)) LClrCell(cell, iconList);
  311.         */
  312.         LSetCell("   ", 3, cell, iconList);
  313.         while (LNextCell(TRUE, TRUE, &cell, iconList)) 
  314.             LSetCell("   ", 3, cell, iconList);
  315.     }
  316. }
  317.  
  318.  
  319. /* Update the title and view of the given browser */
  320.  
  321. void updateBrowser(browserWindow)
  322. WindowPtr browserWindow;
  323. {
  324.   OBJECT* cwd = getBrowserTarget(browserWindow);
  325.   CONTEXT* context = getContext(cwd);
  326.  
  327.     /* Update the title of the window with the current type information */
  328.     /* This operation is rather time consuming */
  329.     updateBrowserTitle(browserWindow);
  330.  
  331.     /* Refresh the contents of the browser */
  332.     refreshBrowser(browserWindow);
  333.  
  334.     /* 
  335.         For security, perform some integrity checks for the object.
  336.         This allows the user to notice possible memory leak problems etc.
  337.         in his programs earlier before they cause some totally obscure errors.
  338.         Problems will be reported to console along with a three beeps.
  339.  
  340.         However, since rootContext is so big (= time-consuming to check),
  341.         we never perform the integrity checks for that object.
  342.     */
  343.     /* if (context != rootContext) checkIntegrity(context); */
  344. }    
  345.     
  346.  
  347. /* Update the browser title, using current type information */
  348.  
  349. void updateBrowserTitle(browserWindow)
  350. WindowPtr browserWindow;
  351. {
  352.   OBJECT* cwd = getBrowserTarget(browserWindow);
  353.   int wKind = getWindowKind(browserWindow);
  354.   
  355.     /* Special case: the Root object */
  356.     if (cwd == oUserRoot) {
  357.         SetWTitle(browserWindow, "\pRoot");
  358.         return;
  359.     }
  360.  
  361.     switch (wKind) {
  362.         case BrowserWKind: {
  363.             char* thisName = getBrowserIdent(browserWindow);
  364.             decodeObjectType(thisName, cwd);
  365.             break;
  366.         }
  367.         case CloneBrWKind: {
  368.             OBJECT* object = (OBJECT*)fetchFromList((LIST*)cwd, 1);
  369.  
  370.             if (object == oUserRoot) sprintf(charbuffer, "Root clone family");
  371.             else {
  372.                 PAIR* thisPair = findTypeForward(object);
  373.                 if (thisPair)
  374.                       sprintf(charbuffer, "%s clone family", thisPair->nfa);
  375.                 else sprintf(charbuffer, "<anon> clone family");
  376.             }
  377.             CtoPstr(charbuffer);
  378.             break;
  379.         }
  380.     }
  381.     SetWTitle(browserWindow, charbuffer);             
  382. }
  383.  
  384.  
  385. /* Change the number of columns in the browser */
  386.  
  387. void recolumnBrowser(browserWindow, newCols)
  388. WindowPtr    browserWindow;
  389. int            newCols;
  390. {
  391.   ListHandle     iconList     = getBrowserIcons(browserWindow);
  392.   OBJECT*        cwd            = getBrowserTarget(browserWindow);
  393.   WindowPtr        oldPrevBr    = getPrevBrowser(browserWindow);
  394.   int            oldCols     = ((*iconList)->dataBounds).right;
  395.   int            oldViewMode = getViewMode(iconList);
  396.   
  397.     if (newCols == oldCols) return;
  398.     
  399.     EraseRect(&browserWindow->portRect);
  400.     deleteIconList(iconList);
  401.     iconList = buildIconList(browserWindow, cwd, oldPrevBr, newCols, oldViewMode);
  402.     setBrowserIcons(browserWindow, iconList);
  403.  
  404.     LActivate(TRUE, iconList);
  405.     updateBrowser(browserWindow);
  406.     DrawGrowIcon(browserWindow);
  407. }
  408.   
  409.  
  410. /* React to a double click */
  411.  
  412. void handleDoubleClick(browserWindow, optKey)
  413. WindowPtr browserWindow;
  414. int          optKey;
  415. {
  416.   ListHandle iconList   = getBrowserIcons(browserWindow);
  417.   OBJECT*    cwd         = getBrowserTarget(browserWindow);
  418.   CONTEXT*    context     = getContext(cwd); 
  419.   Cell         cell         = LLastClick(iconList);
  420.   int        index         = cellToIndex(iconList, cell);
  421.   int        viewMode     = getViewMode(iconList);
  422.   PAIR*        thisPair     = indexedFind(context, index, viewMode);
  423.   int        pairKind;
  424.   OBJECT*    object;
  425.                  
  426.     /* If the object contains a pair for the selected cell */
  427.     if (thisPair) {
  428.         switch (pairKind = recognizeObject(thisPair->ofa)) {
  429.             case PRIMITIVE:
  430.                 if (optKey) {
  431.                     /* If option key is pressed during double click, execute the primitive */
  432.                     numberToKeyBuffer(browserTask, (int)cwd);
  433.                     textToKeyBuffer(browserTask, " CD");
  434.                     crsToKeyBuffer(browserTask);
  435.                     numberToKeyBuffer(browserTask, thisPair->ofa);
  436.                     textToKeyBuffer(browserTask, " execute");
  437.                     crsToKeyBuffer(browserTask);
  438.                 }
  439.                 else SysBeep(1);
  440.                 break;
  441.  
  442.             case REF: 
  443.             case VAR: 
  444.             case CONST: 
  445.             {
  446.                 switch (pairKind) {
  447.                     case REF:     object = *getREFslot(thisPair);      break;
  448.                     case VAR:     object = *getVARslot(cwd, thisPair); break;
  449.                     case CONST: object = *getREFslot(thisPair);      break;
  450.                 }
  451.                 
  452.                 if (isContextObject(object)) {
  453.                     if (optKey) reuseBrowser(object, thisPair->nfa, browserWindow, BrowserWKind); 
  454.                     else openBrowser(object, thisPair->nfa, BrowserWKind);    
  455.                 }
  456.                 else SysBeep(1);
  457.                 break;
  458.             }
  459.  
  460.             case METHOD: {
  461.                 if (optKey) {
  462.                     /* If option key is pressed during double click, execute the method */
  463.                     numberToKeyBuffer(browserTask, (int)cwd);
  464.                     textToKeyBuffer(browserTask, " CD");
  465.                     crsToKeyBuffer(browserTask);
  466.                     numberToKeyBuffer(browserTask, thisPair->ofa);
  467.                     textToKeyBuffer(browserTask, " execute");
  468.                     crsToKeyBuffer(browserTask);
  469.                 }
  470.                 else {
  471.                     WindowPtr     methodWindow;
  472.                     TASK**      tempUp = up;
  473.                       PAIR*       typePair;
  474.  
  475.                     yieldTo(browserTask);
  476.                     pushContext((int*)cwd);
  477.  
  478.                     if (typePair = findTypeForward(cwd))
  479.                          sprintf(charbuffer, "%s METHOD %s", typePair->nfa, thisPair->nfa);
  480.                     else sprintf(charbuffer, "METHOD %s", thisPair->nfa);
  481.                     CtoPstr(charbuffer);
  482.  
  483.                     /* Set the output of browser task temporarily to a window */
  484.                     methodWindow = buildTEWindow(charbuffer);
  485.                     (*browserTask)->window = (int*)methodWindow;
  486.                     ShowWindow(methodWindow);
  487.                     outfile = (FILE*)0;
  488.  
  489.                     setMethodContext(methodWindow, cwd);
  490.                     setMethodPair(methodWindow, thisPair);
  491.  
  492.                     SelectWindow(methodWindow);
  493.                     decompile(thisPair->ofa);
  494.  
  495.                     /* Set the output of browser task back to console */
  496.                     (*browserTask)->window = NIL;
  497.                     /* outfile = confile; */
  498.                     errfile = confile;
  499.                     theTask = NIL;
  500.                     theText = NIL;
  501.  
  502.                     (void)popContext();
  503.                     yieldTo(tempUp);
  504.                 }
  505.                 break;
  506.             }
  507.         }
  508.     }
  509.     else if (AnonymousSlots) {
  510.         /* No matching pair -> handle the possible anonymous slot access */
  511.         int position = index - MaskedPairs; 
  512.         object = (OBJECT*)*((int*)cwd->mfa + position + 1);
  513.  
  514.         if (isContextObject(object)) {
  515.             if (optKey) reuseBrowser(object, NIL, browserWindow, BrowserWKind); 
  516.             else openBrowser(object, NIL, BrowserWKind);    
  517.         }
  518.         else SysBeep(1);
  519.     }
  520. }
  521.  
  522.  
  523. /* 
  524.     Open browsers for all the parent or child clone families 
  525.     on the basis of the currently selected browser window.
  526. */
  527. void browseCloneFamilies(browserWindow, familyStr)
  528. WindowPtr browserWindow;
  529. char* familyStr;    /* parameter string should be either "parent" or "child" */
  530. {
  531.     OBJECT* cwd;
  532.     LIST* cwdFamily;
  533.     int index;
  534.                     
  535.     /* 
  536.         This operation can be invoked from both "normal" browser windows
  537.         and from clone family windows. We must initialize the variables
  538.         differently depending on this.
  539.     */
  540.     switch (getWindowKind(browserWindow)) {
  541.         case BrowserWKind:
  542.             cwd = getBrowserTarget(browserWindow);
  543.             if (strcmp(familyStr, "parent") == 0)
  544.                  cwdFamily = getContext(cwd)->parentFamilies;
  545.             else cwdFamily = getContext(cwd)->childFamilies;
  546.             break;
  547.                         
  548.         case CloneBrWKind:
  549.             /* Note: this assumes that the clone family has at least one member */
  550.             cwd = fetchFromList((LIST*)getBrowserTarget(browserWindow), 1);
  551.             if (strcmp(familyStr, "parent") == 0)
  552.                  cwdFamily = getContext(cwd)->parentFamilies;
  553.             else cwdFamily = getContext(cwd)->childFamilies;
  554.             break;
  555.     }
  556.  
  557.     /* If the family list is empty -> do nothing */
  558.     if (cwdFamily->logicalSize == 0) return;
  559.  
  560.     /* Otherwise, open a clone family browser for each of the members */
  561.     for (index = 1; index <= cwdFamily->logicalSize; index++) {                    
  562.         LIST* thisFamily = (LIST*)fetchFromList(cwdFamily, index);
  563.  
  564.         if (!isContextObject((OBJECT*)thisFamily)) {
  565.             fprintf(confile, "== Integrity error detected: %s family is not a valid object ==\n", familyStr);
  566.             reportIntegrityError();
  567.             ownLongJmp();
  568.         }
  569.                         
  570.         /* The window will be opened only if the family contains members */
  571.         /* (if the system works correctly, all the families do contain members) */
  572.         if (thisFamily->logicalSize > 0) {
  573.  
  574.             /*
  575.                 Since we may have to open multiple windows,  
  576.                 set the browser task to open the browser on background
  577.                 so as to allow multitasking to operate without delays. 
  578.             */
  579.  
  580.             /* Remember that 'numberToKeyBuffer' changes 'charbuffer' */
  581.             numberToKeyBuffer(browserTask, (int)thisFamily);
  582.             textToKeyBuffer(browserTask, " cfBrowse");
  583.             crsToKeyBuffer(browserTask);
  584.         }
  585.         else {
  586.             fprintf(confile, "== Integrity error detected: empty %s family ==\n", familyStr);
  587.             reportIntegrityError();
  588.             ownLongJmp();
  589.         }
  590.     }
  591. }
  592.  
  593.  
  594. /* Assign the given object to the selected slot in the target window */
  595. /* 
  596.     The object will be assigned only if there is exactly one slot selected
  597.     in the icon list, and that slot is either a shared variable (REF) or
  598.     an instance variable (VAR)
  599.  
  600.     Actually, the same checks are performed in 'doBrowserDisable', but they
  601.     are kept here for safety.
  602. */
  603. void assignObject(browserWindow, source)
  604. WindowPtr browserWindow;    /* The target window */
  605. OBJECT* source;                /* The object to be assigned */
  606. {
  607.   OBJECT* cwd           = getBrowserTarget(browserWindow);
  608.   ListHandle iconList = getBrowserIcons(browserWindow);
  609.   int selected           = countSelectedCells(iconList);
  610.  
  611.     if (selected != 1) {
  612.         SysBeep(1);
  613.         fprintf(confile, "== Exactly one variable slot must be active during assignment ==\n");
  614.         return;
  615.     }
  616.     else {
  617.         PAIR*      thisPair;
  618.         OBJECT*  target;
  619.         OBJECT** slot;
  620.         int         pairKind;
  621.         Cell      cell;
  622.  
  623.         cell.h = -1; cell.v = 0;
  624.         (void)nextSelectedCell(iconList, &cell);
  625.         
  626.         thisPair = cellToPair(browserWindow, cell);    
  627.         if (!thisPair) {
  628.             SysBeep(1);
  629.             fprintf(confile, "== The target slot in assignment must be either a VAR or a REF ==\n");
  630.             return;
  631.         }
  632.         
  633.         target = thisPair->ofa;
  634.         pairKind = recognizeObject(target);
  635.         
  636.         switch (pairKind) {
  637.             case REF:
  638.             case VAR:
  639.                 switch (pairKind) {
  640.                     case REF:    slot = getREFslot(thisPair);         break;
  641.                     case VAR:    slot = getVARslot(cwd, thisPair);     break;
  642.                 }
  643.                 *slot = source;
  644.                 updateBrowser(browserWindow);
  645.                 
  646.                 /* Select the second topmost window so as to confirm */
  647.                 /* which object has been assigned */
  648.                 openBrowser(source, thisPair->nfa, BrowserWKind);    
  649.                 break;
  650.             default:
  651.                 SysBeep(1);
  652.                 fprintf(confile, "== The target slot in assignment must be either a VAR or a REF ==\n");
  653.                 break;
  654.         }
  655.     }
  656. }
  657.  
  658.  
  659. /* Open command shell (value editor) window for the given object */
  660.  
  661. void openShellForThis(object)
  662. OBJECT* object;
  663. {
  664.     TASK**         newTask = buildTask();
  665.     WindowPtr     newWindow;
  666.     PAIR*         typePair;
  667.  
  668.     /* In the browser mode, we copy the initial 
  669.        context from the current browser task.
  670.  
  671.        The execution will be started from 'shell' rather than 'boot'.
  672.     */
  673.     setTaskBehavior(newTask, oShell);
  674.     setTaskCWD(newTask, object);
  675.  
  676.     typePair = findTypeForward(object);
  677.     if (typePair)
  678.          sprintf(charbuffer, "Command Shell (%s:%d)", typePair->nfa, object);
  679.     else sprintf(charbuffer, "Command Shell (object %d)", object);
  680.     CtoPstr(charbuffer);
  681.  
  682.     /* Build a new TextEdit window for the newly created task */
  683.     newWindow = buildTEWindow(charbuffer);
  684.     if (newWindow) {
  685.         (*newTask)->window = (int*)newWindow;
  686.         ShowWindow(newWindow);
  687.         SelectWindow(newWindow);
  688.     }
  689.     activateTask(newTask);
  690. }
  691.  
  692.  
  693. /* ------------------------------------------------------------------------ */
  694. /* Icon List operations */
  695.  
  696. /* Build an icon list structure, using the Mac Toolbox List Manager Package */
  697. /* Note that these lists have nothing to do with the lists defined in 'lists.h' */
  698.  
  699. ListHandle buildIconList(thisWindow, target, prevBrowser, columnNumber, viewWhat)
  700. WindowPtr thisWindow;
  701. OBJECT*      target;
  702. WindowPtr prevBrowser;
  703. int          columnNumber;
  704. int          viewWhat;
  705. {
  706.     ListHandle iconList;
  707.     Point cSize;
  708.     Rect viewRect, boundsRect;
  709.  
  710.     /* Set the cell dimensions (horizontal and vertical) */
  711.     /* Defaults are h: 480 / cols and v: 18 */    
  712.     cSize.h = ICONLINELENGTH / columnNumber;
  713.     cSize.v = ICONCELLHEIGHT;
  714.     
  715.     boundsRect.left = 0;
  716.     boundsRect.top = 0;
  717.     boundsRect.right = columnNumber;
  718.     boundsRect.bottom = 1;
  719.     
  720.     BlockMove(&thisWindow->portRect, &viewRect, sizeof(Rect));
  721.     viewRect.right  -= 15;    /* Must be 15 */
  722.     viewRect.bottom -= 15;    /* Must be 15 */
  723.     
  724.     /* Build a new Mac Toolbox List */
  725.     iconList = LNew(&viewRect,     /* Screen size of the icon list */
  726.                 &boundsRect,     /* Number of rows and columns */
  727.                 cSize,         /* Cell size */
  728.                 333,         /* List definition (LDEF) resource id, default=0/custom=333 */
  729.                 thisWindow, /* The window in which the icon list resides */
  730.                 TRUE,        /* drawIt (cell drawing is enabled) */
  731.                 TRUE,        /* hasGrow (there is a size box) */ 
  732.                 TRUE,         /* scrollHoriz (there is a horizontal scroll bar) */
  733.                 TRUE);        /* scrollVert (there is a vertical scroll bar) */
  734.                     
  735.     /* Empty cells should not be highlighted */
  736.     (*iconList)->selFlags |= lNoNilHilite;
  737.  
  738.     /* Create the icon list information structure */
  739.     (*iconList)->refCon = (long)createLinfo(viewWhat, target, prevBrowser);
  740.  
  741.     return(iconList);
  742. }
  743.  
  744.  
  745. /* Delete an icon list structure */
  746.  
  747. void deleteIconList(iconList)
  748. ListHandle iconList;
  749. {
  750.     LINFO* thisLinfo = (LINFO*)(*iconList)->refCon;
  751.  
  752.     /* Delete the associated information structure */
  753.     deleteLinfo(thisLinfo);
  754.  
  755.     /* Delete the Mac Toolbox List itself */
  756.     LDispose(iconList);
  757. }
  758.  
  759.  
  760. /* Add or remove columns from the icon list if needed */
  761.  
  762. void resizeIconList(iconList, cwd)
  763. ListHandle iconList;
  764. OBJECT* cwd;
  765. {
  766.     CONTEXT* context = getContext(cwd);
  767.     int viewMode = getViewMode(iconList);
  768.     int cols = ((*iconList)->dataBounds).right;
  769.     int lastRow;
  770.     int delta;    /* Change in row count */
  771.     Cell cell;
  772.  
  773.     /* Set the values of the global icon list item counts */
  774.  
  775.     /* Number of appropriate pairs in the current object */ 
  776.     /* This is a global variable */
  777.     MaskedPairs = maskedCountPairs(context, viewMode);
  778.     
  779.     /* Number of anynymous (array) slots in the current object */
  780.     /* This is a global variable */
  781.     AnonymousSlots = countArraySlots(cwd);
  782.  
  783.     /* In behavior display mode, we don't display the anonymous array slots */
  784.     /* so they will not be added to the cell count when resizing the icon list */
  785.     /* CellsInTotal is also a global variable that tells how many cells/icons the */
  786.     /* current browser has */
  787.     if (viewMode != BEHAVIOR) 
  788.          CellsInTotal = MaskedPairs + AnonymousSlots;
  789.     else CellsInTotal = MaskedPairs;
  790.  
  791.     lastRow = (CellsInTotal+cols-1) / cols;
  792.     delta = lastRow - ((*iconList)->dataBounds).bottom;
  793.  
  794.     if (delta > 0) {    /* Lines must be added */
  795.         /* second argument must be bigger than biggest possible column number */
  796.         LAddRow(delta, -1, iconList);
  797.         return;
  798.     }
  799.     if (delta < 0) {    /* Lines must be deleted */
  800.         LDelRow(-delta, 0, iconList);
  801.     }
  802. }
  803.  
  804.  
  805. /* Determine the correct size for the browser */
  806. /* This routine is used for zoom box operation */
  807.  
  808. void determineBrowserWindowSize(browserWindow)
  809. WindowPtr browserWindow;
  810. {
  811.   ListHandle iconList = getBrowserIcons(browserWindow);        
  812.   int columns = ((*iconList)->dataBounds).right;
  813.   WStateData** wDataHdl;
  814.   Rect newRect;
  815.   int offsetLeft = 0 - browserWindow->portBits.bounds.left;
  816.   int offsetTop  = 0 - browserWindow->portBits.bounds.top;
  817.   int width;
  818.   int height;
  819.  
  820.     if (columns == 1) {
  821.         width = ICONLINELENGTH / 2 + SCROLLBARWIDTH;
  822.         height = CellsInTotal*ICONCELLHEIGHT + SCROLLBARWIDTH + 6;
  823.     }
  824.     else {
  825.         width = ICONLINELENGTH + SCROLLBARWIDTH;
  826.         height = (((CellsInTotal+columns-1) / 4) * ICONCELLHEIGHT) + SCROLLBARWIDTH + 6;
  827.     }
  828.     
  829.     /* Ensure that window doesn't become too large for the screen */
  830.     if (height > screenBits.bounds.bottom - (SCROLLBARWIDTH*2 + 15))
  831.         height = screenBits.bounds.bottom - (SCROLLBARWIDTH*2 + 15);
  832.  
  833.     /* Ensure that window doesn't become too small either */
  834.     else if (height < ICONCELLHEIGHT*3 + SCROLLBARWIDTH) 
  835.              height = ICONCELLHEIGHT*3 + SCROLLBARWIDTH;
  836.  
  837.     /* Set the calculated browser size for zoom box usage */
  838.     SetRect(&newRect, offsetLeft, offsetTop, offsetLeft + width, offsetTop + height);
  839.     wDataHdl = (WStateData**)((WindowPeek)browserWindow)->dataHandle;
  840.     BlockMove(&newRect, &(*wDataHdl)->stdState, sizeof(Rect));
  841. }
  842.  
  843.  
  844. /* Return true if there is yet another selected cell in the icon list */
  845. /* The selected cell is returned in parameter 'nextCell' */
  846.  
  847. int nextSelectedCell(iconList, nextCell)
  848. ListHandle iconList;
  849. Cell* nextCell;
  850. {
  851.   int cols = (*iconList)->dataBounds.right;
  852.   int rows = (*iconList)->dataBounds.bottom;
  853.   int selected = FALSE;
  854.  
  855.     while (nextCell->v < rows) {
  856.  
  857.         nextCell->h++;
  858.  
  859.         if (nextCell->h >= cols) {
  860.             nextCell->h = 0;
  861.             nextCell->v++;
  862.         }
  863.  
  864.         if (selected = LGetSelect(FALSE, nextCell, iconList)) break;
  865.     }
  866.  
  867.     return(selected);
  868. }
  869.  
  870.  
  871. /* Return true if there is yet another selected cell in the icon list */
  872. /* The selected cell is returned in parameter 'prevCell' */
  873.  
  874. int prevSelectedCell(iconList, prevCell)
  875. ListHandle iconList;
  876. Cell* prevCell;
  877. {
  878.   int cols = (*iconList)->dataBounds.right;
  879.   int selected = FALSE;
  880.  
  881.     while (prevCell->v >= 0) {
  882.  
  883.         prevCell->h--;
  884.         
  885.         if (prevCell->h < 0) {
  886.             prevCell->h = cols-1;
  887.             prevCell->v--;
  888.         }
  889.  
  890.         if (selected = LGetSelect(FALSE, prevCell, iconList)) break;
  891.     }
  892.  
  893.     return(selected);
  894. }
  895.  
  896.  
  897. /* Return the number of selected cells in the icon list */
  898.  
  899. int countSelectedCells(iconList)
  900. ListHandle iconList;
  901. {
  902.   Cell cell;
  903.   int count = 0;
  904.  
  905.     cell.h = -1; cell.v = 0;
  906.     
  907.     while (nextSelectedCell(iconList, &cell)) count++;
  908.     return(count);
  909. }
  910.  
  911.  
  912. /* Add a new cell (pair) to the object being browsed */
  913.  
  914. void addNewCell(browserWindow, slotType, name)
  915. WindowPtr browserWindow;
  916. int          slotType;
  917. char* name;
  918. {
  919.   OBJECT*     cwd = getBrowserTarget(browserWindow);
  920.   CONTEXT*  context;
  921.   PAIR*     newPair;
  922.   OBJECT*     object;
  923.  
  924.     /* The current version does not support addition of cells to descendants */
  925.     if (whoToModify == DERIVATIVES) {
  926.         SysBeep(1);
  927.         fprintf(confile, "== This version does not support addition of slots in the 'derivatives' ==\n");  
  928.         fprintf(confile, "== mode (use 'clone family' mode and CUT/COPY/PASTE instead) ==\n");
  929.         return;
  930.     }
  931.     
  932.     /* Create a new clone family if needed */
  933.     if (whoToModify == THIS_ONLY) deriveObject(cwd);
  934.     
  935.     /* Add the appropriate slot */
  936.     switch (slotType) {
  937.         case REF:
  938.             object = createClosure(2);
  939.             object->mfa->efa = (int*)oREF;
  940.             break;
  941.         case REF+8:
  942.             pBuildDir();
  943.             object = createClosure(2);
  944.             object->mfa->efa = (int*)oREF;
  945.             object->mfa->pfa = (int*)popData();
  946.             break;
  947.         case VAR:
  948.             object = createClosure(2);
  949.             object->mfa->efa = (int*)oVAR;
  950.             object->mfa->pfa = (int*)cwd->sfa;
  951.             resizeFamilyMembers(cwd, cwd->sfa+1);
  952.             break;
  953.         case CONST:
  954.             object = createClosure(2);
  955.             object->mfa->efa = (int*)oSharedConst;
  956.             break;
  957.         case METHOD:
  958.             object = createClosure(1);
  959.             break;
  960.     }
  961.  
  962.     context = getContext(cwd);
  963.     newPair = addPair(context, name, object);
  964.  
  965.     /* Possibly change the object's clone family */
  966.     confirmObjectType(cwd, whoToModify, ADDING_SOMETHING);
  967.     updateBrowser(browserWindow);
  968. }
  969.  
  970.  
  971. /* Remove a given cell (pair) from the object being browsed */
  972.  
  973. void removeCell(browserWindow, cell)
  974. WindowPtr browserWindow;
  975. Cell cell;
  976. {
  977.   PAIR*    thisPair = cellToPair(browserWindow, cell);
  978.  
  979.     if (!thisPair) return;
  980.  
  981.     unlinkPair(thisPair);
  982.     free(thisPair);
  983. }
  984.  
  985.  
  986. /* Change encapsulation of a given cell (pair) */
  987.  
  988. void hideShowCell(browserWindow, cell)
  989. WindowPtr browserWindow;
  990. Cell cell;
  991. {
  992.   PAIR* thisPair = cellToPair(browserWindow, cell);
  993.  
  994.     if (!thisPair) return;
  995.  
  996.     if (thisPair->ffa & HiddenFlag) 
  997.         /* reset the hidden flag */
  998.         thisPair->ffa &= ~HiddenFlag;
  999.     else 
  1000.         /* raise the hidden flag */
  1001.         thisPair->ffa |= HiddenFlag; 
  1002. }
  1003.  
  1004.  
  1005. /* Add a character to the property name in a cell */
  1006.  
  1007. void addToCell(iconList, cell, c)
  1008. ListHandle iconList;
  1009. Cell       cell;
  1010. char       c;
  1011. {
  1012.   char qualifier[16];
  1013.   char name[128];
  1014.   short count = CHARBUFLEN;
  1015.   int index = cellToIndex(iconList, cell);
  1016.  
  1017.       if (index > MaskedPairs) { SysBeep(1); return; }
  1018.  
  1019.     LGetCell(charbuffer, &count, cell, iconList);
  1020.     charbuffer[count] = 0;    
  1021.  
  1022.     /* We have to initialize name, because charbuffer may not contain two words */
  1023.     name[0] = 0;
  1024.     sscanf(charbuffer, "%s %s", qualifier, name);
  1025.     name[strlen(name)+1] = 0;
  1026.     name[strlen(name)] = c;
  1027.     sprintf(charbuffer, "%s %s", qualifier, name);
  1028.  
  1029.     LSetCell(charbuffer, (short)(strlen(qualifier)+strlen(name)+1), cell, iconList);
  1030. }
  1031.  
  1032.  
  1033. /* Remove a character from the property name in a cell */
  1034.  
  1035. void removeFromCell(iconList, cell)
  1036. ListHandle iconList;
  1037. Cell       cell;
  1038. {
  1039.   char qualifier[16];
  1040.   char name[128];
  1041.   short count = CHARBUFLEN;
  1042.   int index = cellToIndex(iconList, cell);
  1043.   
  1044.       if (index > MaskedPairs) { SysBeep(1); return; }
  1045.  
  1046.     LGetCell(charbuffer, &count, cell, iconList);
  1047.     charbuffer[count] = 0;    
  1048.  
  1049.     name[0] = 0;
  1050.     sscanf(charbuffer, "%s %s", qualifier, name);
  1051.     if (strlen(name)) {
  1052.         name[strlen(name)-1] = 0;
  1053.         sprintf(charbuffer, "%s %s", qualifier, name);
  1054.         LSetCell(charbuffer, (short)(strlen(qualifier)+strlen(name)+1), cell, iconList);
  1055.     }
  1056.     else SysBeep(1);
  1057. }
  1058.  
  1059.  
  1060. /* Rename the property in a cell using the possibly changed name */
  1061.  
  1062. void renameCell(browserWindow, cell)
  1063. WindowPtr browserWindow;
  1064. Cell      cell;
  1065. {
  1066.   OBJECT* cwd = getBrowserTarget(browserWindow);
  1067.   ListHandle iconList = getBrowserIcons(browserWindow);
  1068.   PAIR*    thisPair; 
  1069.   char qualifier[16];
  1070.   char name[128];
  1071.   short count = CHARBUFLEN;
  1072.  
  1073.     /* The current version does not support renaming of cells to descendants */
  1074.     if (whoToModify == DERIVATIVES) {
  1075.         SysBeep(1);
  1076.         fprintf(confile, "== This version does not support renaming of slots in the 'derivatives' ==\n");  
  1077.         fprintf(confile, "== mode (use 'clone family' mode and CUT/COPY/PASTE instead) ==\n");
  1078.         return;
  1079.     }
  1080.     
  1081.      /* Create a new clone family if needed */
  1082.      if (whoToModify == THIS_ONLY) deriveObject(cwd);
  1083.  
  1084.       thisPair = cellToPair(browserWindow, cell);
  1085.     if (!thisPair) return;
  1086.  
  1087.     LGetCell(charbuffer, &count, cell, iconList);
  1088.     charbuffer[count] = 0;    
  1089.  
  1090.     name[0] = 0;
  1091.     sscanf(charbuffer, "%s %s", qualifier, name);
  1092.     if (strlen(name) && thisPair) {
  1093.         renamePair(thisPair, allocStrCpy(name));        
  1094.         /* Possibly change the object's clone family */
  1095.         confirmObjectType(cwd, whoToModify, RENAMING_SOMETHING);
  1096.         updateBrowser(browserWindow);
  1097.     }
  1098.     else SysBeep(1);
  1099. }
  1100.  
  1101.  
  1102. /* Convert cells to one-dimensional indexes */
  1103. /* Indexing starts from number one */
  1104.  
  1105. int cellToIndex(iconList, cell)
  1106. ListHandle iconList;
  1107. Cell cell;
  1108. {
  1109.     return (cell.v * ((*iconList)->dataBounds).right + cell.h + 1);    
  1110. }
  1111.  
  1112.  
  1113. /* Given a cell, return the corresponding pair */
  1114.  
  1115. PAIR* cellToPair(browserWindow, cell)
  1116. WindowPtr browserWindow;
  1117. Cell cell;
  1118. {
  1119.   ListHandle iconList    = getBrowserIcons(browserWindow);
  1120.   OBJECT*     cwd          = getBrowserTarget(browserWindow);
  1121.   CONTEXT*     context     = getContext(cwd); 
  1122.   int          index          = cellToIndex(iconList, cell);
  1123.   int         viewMode    = getViewMode(iconList);
  1124.  
  1125.     return(indexedFind(context, index, viewMode));
  1126. }
  1127.  
  1128.  
  1129. /* Find the correct pair in the context, taking the mask into account */
  1130.  
  1131. PAIR* indexedFind(context, index, viewMode)
  1132. CONTEXT* context;
  1133. int    index;
  1134. int viewMode;
  1135. {
  1136.     switch (viewMode) {
  1137.         case ALL:
  1138.             return(findAllAsIndexed(context, index));
  1139.             break;
  1140.         case DATA:
  1141.             return(findDataAsIndexed(context, index));
  1142.             break;
  1143.         case BEHAVIOR:
  1144.             return(findOperAsIndexed(context, index));
  1145.             break;
  1146.     }
  1147. }
  1148.  
  1149.  
  1150. /* Get the next pair with the desired search mask */
  1151.  
  1152. PAIR* getNextMaskedPair(thisPair, viewMode)
  1153. PAIR* thisPair;
  1154. int   viewMode;
  1155. {
  1156.     while (thisPair) {
  1157.         switch (viewMode) {
  1158.             case ALL:
  1159.                 return(thisPair);
  1160.                 break;
  1161.             case DATA:
  1162.                 if (thisPair->ofa) switch(recognizeObject(thisPair->ofa)) {
  1163.                     case REF:
  1164.                     case VAR:
  1165.                     case CONST:
  1166.                         return(thisPair);
  1167.                 }
  1168.                 break;
  1169.             case BEHAVIOR:
  1170.                 if (thisPair->ofa) switch(recognizeObject(thisPair->ofa)) {
  1171.                     case PRIMITIVE:
  1172.                     case METHOD:
  1173.                         return(thisPair);
  1174.                 }
  1175.                 break;
  1176.         }
  1177.         thisPair = thisPair->sfa;
  1178.     }
  1179.     return(NIL);
  1180. }
  1181.  
  1182.  
  1183. /* Count the number of pairs, taking the mask into account */
  1184.  
  1185. int maskedCountPairs(context, viewMode)
  1186. CONTEXT* context;
  1187. int viewMode;
  1188. {
  1189.     switch (viewMode) {
  1190.         case ALL:
  1191.             return(countAllPairs(context));
  1192.             break;
  1193.         case DATA:
  1194.             return(countDataPairs(context));
  1195.             break;
  1196.         case BEHAVIOR:
  1197.             return(countOperPairs(context));
  1198.             break;
  1199.     }
  1200. }
  1201.  
  1202.  
  1203. /* Check if an object is an array rather than conventional object */
  1204. /*
  1205.     Return zero if the object is a normal object.
  1206.     Return the count of anonymous data slots otherwise.
  1207. */
  1208. int countArraySlots(ctxtObject)
  1209. OBJECT*  ctxtObject;
  1210. {
  1211.   CONTEXT* thisContext = getContext(ctxtObject);
  1212.   PAIR* thisPair = thisContext->firstPair;
  1213.   int array = TRUE;
  1214.   
  1215.     while (thisPair) {
  1216.         if (recognizeObject(thisPair->ofa) == VAR) {
  1217.             array = FALSE;
  1218.             break;
  1219.         }
  1220.         thisPair = thisPair->sfa;
  1221.     }
  1222.     
  1223.     if (array) return(ctxtObject->sfa - DATAOFFSET);
  1224.     else return(0); 
  1225. }
  1226.  
  1227.  
  1228. /*---------------------------------------------------------------------------*/
  1229. /* Auxiliary operations */
  1230.  
  1231. /* Build a textual description of an object */
  1232. /* The resulting format is:
  1233.         'name (type)',
  1234.         where name is either name or '<anon>', and
  1235.         type is either "type:id#" or "id#".
  1236.  
  1237.     The result will be stored in global variable 'charbuffer'.
  1238. */
  1239.  
  1240. void decodeObjectType(thisName, object)
  1241. char* thisName;
  1242. OBJECT* object;
  1243. {
  1244.   PAIR* typePair = findTypeForward(object);
  1245.   
  1246.     if (thisName == NIL) thisName = "<anon>";
  1247.  
  1248.     if (typePair) 
  1249.          sprintf(charbuffer, "%s (%s:%d)", thisName, typePair->nfa, object);
  1250.     else sprintf(charbuffer, "%s (%d)", thisName, object);
  1251.  
  1252.     CtoPstr(charbuffer);
  1253. }
  1254.  
  1255.  
  1256. /* Return an appropriate string */
  1257.  
  1258. char* asString(objectKind, hidden)
  1259. int objectKind;
  1260. int hidden;
  1261. {
  1262.   char* string;
  1263.  
  1264.     switch(objectKind) {
  1265.         case PRIMITIVE:    string = " P"; break;
  1266.         case REF:        string = " R"; break;
  1267.         case VAR:        string = " V"; break;
  1268.         case CONST:        string = " C"; break;
  1269.         case METHOD:    string = " M"; break;
  1270.     }
  1271.  
  1272.     /* 'Hidden' contains the encapsulation information. */
  1273.     
  1274.     if (hidden) *string = '_';
  1275.     else         *string = '^';
  1276.  
  1277.     return(string);
  1278. }
  1279.     
  1280.     
  1281. /*---------------------------------------------------------------------------*/
  1282. /* Icon list information field operations */
  1283.  
  1284. /* Create a list information structure */
  1285. /* 
  1286.     Each icon list must contain one of these structures stored
  1287.     its 'RefCon' field.
  1288. */
  1289.  
  1290. LINFO* createLinfo(viewMode, target, lastBrowser)
  1291. int viewMode;    /* Icon list view mode (see 'portGlobal.h') */
  1292. OBJECT* target;
  1293. WindowPtr lastBrowser;
  1294. {
  1295.   LINFO* newLinfo = (LINFO*)mycalloc(1, sizeof(LINFO));
  1296.   
  1297.   newLinfo->lMode  = viewMode;
  1298.   newLinfo->target = target;
  1299.   newLinfo->prevBrowser = lastBrowser;
  1300.   
  1301.   return(newLinfo);
  1302. }
  1303.  
  1304.  
  1305. /* Delete a list information structure */
  1306.  
  1307. void deleteLinfo(thisLinfo)
  1308. LINFO* thisLinfo;
  1309. {
  1310.     free(thisLinfo);
  1311. }
  1312.  
  1313.  
  1314. /* Return view mode info */
  1315.  
  1316. int getViewMode(iconList)
  1317. ListHandle iconList;
  1318. {
  1319.   LINFO* thisLinfo = (LINFO*)(*iconList)->refCon;
  1320.   
  1321.     if (thisLinfo) return(thisLinfo->lMode);
  1322.     else return(ALL);
  1323. }
  1324.  
  1325.  
  1326. /* Set view mode info */
  1327.  
  1328. void setViewMode(iconList, viewMode)
  1329. ListHandle iconList;
  1330. int           viewMode;
  1331. {
  1332.   LINFO* thisLinfo = (LINFO*)(*iconList)->refCon;
  1333.   
  1334.     if (thisLinfo) thisLinfo->lMode = viewMode;
  1335. }
  1336.  
  1337.  
  1338. /* Given a browser window, get the object being browsed */
  1339.  
  1340. OBJECT* getBrowserTarget(browserWindow)
  1341. WindowPtr browserWindow;
  1342. {
  1343.   ListHandle iconList = getBrowserIcons(browserWindow);
  1344.   LINFO* thisLinfo;
  1345.   
  1346.     if (!iconList) return(NIL);
  1347.     
  1348.     thisLinfo = (LINFO*)(*iconList)->refCon;
  1349.     if (thisLinfo) return(thisLinfo->target);
  1350.     else return(NIL);
  1351. }
  1352.  
  1353.  
  1354. /* Set the 'target' field of a browser window (stored in iconList's LINFO structure) */
  1355.  
  1356. void setBrowserTarget(browserWindow, target)
  1357. WindowPtr browserWindow;
  1358. OBJECT* target;
  1359. {
  1360.   ListHandle iconList = getBrowserIcons(browserWindow);
  1361.   LINFO* thisLinfo;
  1362.  
  1363.     if (!iconList) return;
  1364.     
  1365.     thisLinfo = (LINFO*)(*iconList)->refCon;
  1366.     if (thisLinfo) thisLinfo->target = target;
  1367. }
  1368.  
  1369.  
  1370. /* Given a browser window, get the previous one */
  1371.  
  1372. WindowPtr getPrevBrowser(browserWindow)
  1373. WindowPtr browserWindow;
  1374. {
  1375.   ListHandle iconList = getBrowserIcons(browserWindow);
  1376.   LINFO* thisLinfo;
  1377.  
  1378.       if (!iconList) return (NIL);
  1379.   
  1380.     thisLinfo = (LINFO*)(*iconList)->refCon;
  1381.     if (thisLinfo) return(thisLinfo->prevBrowser);
  1382.     else return(NIL);
  1383. }
  1384.  
  1385.  
  1386. /* Set the 'prevBrowser' field of a browser window (stored in iconList's LINFO structure) */
  1387.  
  1388. void setPrevBrowser(browserWindow, previous)
  1389. WindowPtr browserWindow;
  1390. WindowPtr previous;
  1391. {
  1392.   ListHandle iconList = getBrowserIcons(browserWindow);
  1393.   LINFO* thisLinfo;
  1394.  
  1395.     if (!iconList) return;
  1396.     
  1397.     thisLinfo = (LINFO*)(*iconList)->refCon;
  1398.     if (thisLinfo) thisLinfo->prevBrowser = previous;
  1399. }
  1400.  
  1401.